#include <vector>
#include <iostream>
#include <pthread.h>
#include <functional>
#include <unistd.h>

#ifndef _THREAD_ARRAY_HPP_
#define _THREAD_ARRAY_HPP_


typedef void (*fun_t) (); 


template < class T >
class Task
{
    using func_t = std::function<void(T)>;
    public:
        Task(func_t f,T data)
            :_f(f)
            ,_isrunning(false)
            ,_isdetach(false)
            ,_data(data)
        {
            ;
        }
        ~Task()
        {
            ;
        }
        // 因为routine是类内函数，默认参数会带this指针
        // 将routine函数变为static函数(在整个.hpp文件能够使用)
        static void* rountine (void* argv)
        {
            // 强转(为了调用自定义函数)
            Task* task = static_cast<Task*>(argv);

            std::cout << "执行rountine" << std::endl;
            // 函数指针与包装器不同，包装器直接往后加"()"，
            // 函数指针：(*函数指针)();

            // 包装器
            task->_f(task->_data);

            // 函数指针
            //(*_t)();

            return nullptr;
        }

        void EnableRunning()
        {
            _isrunning = true;
        }

        void EnableDetach()
        {
            _isdetach = true;
        }

        bool Start()
        {
            // routine是类内函数，默认参数会带this指针，要想解决这个问题：
            // 要么将routine函数放在类外，要么将routine函数变为static函数(在整个.hpp文件能够使用)
            int ret = pthread_create(&_thread,nullptr,rountine,(void*)this);
            // 为了调用自定义函数，将this作为参数传入。

            if(ret == 0)
            {
                std::cout << "create success" << std::endl;
                EnableRunning();

                return true;
            }
            else
            {
                std::cerr << "create fail" << std::endl;

                return false;
            }
        }

        bool Detach()
        {
            int ret = pthread_detach(_thread);

            if(ret == 0)
            {
                std::cout << "Detach success" << std::endl;
                EnableDetach();

                return true;
            }
            else
            {
                std::cerr << "Detach fail" << std::endl;

                return false;
            }
        }

        void Cancel()
        {
            if(_isrunning == false)
            {
                pthread_cancel(_thread);

                std::cout << "取消线程成功" << std::endl;
            }
            else
            {
                std::cout << "取消线程失败" << std::endl;
            }
        } 

        void Join()
        {
            if(_isdetach != true)
            {
                void* ret = nullptr;

                pthread_join(_thread,&ret);
                std::cout << "等待线程成功" << std::endl;
            }
            else
            {
                std::cout << "等待线程失败" << std::endl;;
            }
        }
    private:
        pthread_t _thread;
        func_t _f;        // 要执行的自定义函数
        bool _isrunning;  // 标致是否在运行。
        bool _isdetach;   // 标致是否设置分离分离状态。
        fun_t _t;
        T _data;
};

// class Thread_Task
// {
//     public:
//         Thread_Task()
//         {
//             ;
//         }
//         ~Thread_Task()
//         {
//             ;
//         }
//     private:
//         std::vector<Task> vpt;
// };

#endif